const fs = require('fs');
const path = require('path');
const { createCanvas, loadImage } = require('canvas');

// 处理图像并设置透明度（黑色部分更透明）
async function processImageWithInvertedTransparency(inputPath, outputPath) {
    try {
        // 读取输入图像
        const image = await loadImage(inputPath);
        
        // 创建画布，尺寸与原图相同
        const canvas = createCanvas(image.width, image.height);
        const ctx = canvas.getContext('2d');
        
        // 设置白色背景
        ctx.fillStyle = 'white';
        ctx.fillRect(0, 0, canvas.width, canvas.height);
        
        // 绘制原始图像在白色背景上
        ctx.drawImage(image, 0, 0);
        
        // 获取图像数据
        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
        const data = imageData.data;
        
        // 遍历每个像素，转换为灰度并设置透明度
        for (let i = 0; i < data.length; i += 4) {
            const r = data[i];
            const g = data[i + 1];
            const b = data[i + 2];
            
            // 使用标准感知亮度公式转换为灰度值
            const gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
            
            // 反向透明度模式：越黑越透明（黑色=完全透明，白色=不透明）
            const alpha = 255 - gray; // 黑色部分更透明
            
            // 设置透明度
            data[i + 3] = alpha;
        }
        
        // 将修改后的图像数据放回画布
        ctx.putImageData(imageData, 0, 0);
        
        // 将处理后的图像保存到输出路径
        const outStream = fs.createWriteStream(outputPath);
        const pngStream = canvas.createPNGStream();
        pngStream.pipe(outStream);
        
        return new Promise((resolve, reject) => {
            outStream.on('finish', resolve);
            outStream.on('error', reject);
        });
    } catch (error) {
        console.error('图像处理失败:', error);
        throw error;
    }
}

// 分别处理并保存每一步骤的结果
async function processImageWithSteps(inputPath, outputPathPrefix) {
    try {
        // 读取输入图像
        const image = await loadImage(inputPath);
        
        // 创建画布，尺寸与原图相同
        const canvas = createCanvas(image.width, image.height);
        const ctx = canvas.getContext('2d');
        
        // 步骤1: 设置白色背景
        ctx.fillStyle = 'white';
        ctx.fillRect(0, 0, canvas.width, canvas.height);
        
        // 绘制原始图像在白色背景上
        ctx.drawImage(image, 0, 0);
        
        // 将当前状态保存为第一步结果
        const step1OutputPath = `${outputPathPrefix}_step1.png`;
        await saveCanvasToFile(canvas, step1OutputPath);
        
        // 获取图像数据
        const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
        const data = imageData.data;
        
        // 步骤2: 转换为黑白图像
        for (let i = 0; i < data.length; i += 4) {
            const r = data[i];
            const g = data[i + 1];
            const b = data[i + 2];
            
            // 使用标准感知亮度公式计算亮度值
            const brightness = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
            
            // 设置灰度值
            data[i] = brightness;
            data[i + 1] = brightness;
            data[i + 2] = brightness;
        }
        
        // 将修改后的图像数据放回画布
        ctx.putImageData(imageData, 0, 0);
        
        // 将当前状态保存为第二步结果
        const step2OutputPath = `${outputPathPrefix}_step2.png`;
        await saveCanvasToFile(canvas, step2OutputPath);

        // 步骤3: 直接设置白色并调整透明度（黑色部分更透明）
        for (let i = 0; i < data.length; i += 4) {
            const brightness = data[i]; // 灰度值

            // 设置白色
            data[i] = 255;
            data[i + 1] = 255;
            data[i + 2] = 255;

            // 调整透明度：越暗越透明
            data[i + 3] = brightness;
        }

        // 将修改后的图像数据放回画布
        ctx.putImageData(imageData, 0, 0);

        // 将最终状态保存为第三步结果
        const step3OutputPath = `${outputPathPrefix}_step3.png`;
        await saveCanvasToFile(canvas, step3OutputPath);

        console.log(`所有步骤完成，结果已保存至 ${step1OutputPath}, ${step2OutputPath}, ${step3OutputPath}`);
    } catch (error) {
        console.error('图像处理失败:', error);
        throw error;
    }
}

// 保存画布内容到文件的辅助函数
function saveCanvasToFile(canvas, outputPath) {
    return new Promise((resolve, reject) => {
        const outStream = fs.createWriteStream(outputPath);
        const pngStream = canvas.createPNGStream();
        pngStream.pipe(outStream);
        
        outStream.on('finish', resolve);
        outStream.on('error', reject);
    });
}

// 命令行执行入口修改
if (require.main === module) {
    const args = process.argv.slice(2);
    
    if (args.length < 2) {
        console.log('用法: node image_processor.js [输入文件] [输出文件前缀]');
        process.exit(1);
    }
    
    const inputPath = args[0];
    const outputPathPrefix = args[1];
    
    // 检查输入文件是否存在
    if (!fs.existsSync(inputPath)) {
        console.error(`输入文件不存在: ${inputPath}`);
        process.exit(1);
    }
    
    // 执行图像处理
    processImageWithSteps(inputPath, outputPathPrefix)
        .then(() => {
            console.log(`图像处理完成`);
        })
        .catch(error => {
            console.error('处理过程中发生错误:', error);
            process.exit(1);
        });
}

module.exports = {
    processImageWithInvertedTransparency
};